// $ANTLR 3.2 Sep 23, 2009 12:02:23 C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g 2011-05-18 12:23:53

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162


using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;
using System.Collections.Generic;    
using Antlr.Runtime.Tree;

public partial class DSLParser : Parser
{
    private List<String> errors = new List<string>();
    public override void ReportError(RecognitionException e)
    {
        String hdr = GetErrorHeader(e);
        String msg = GetErrorMessage(e, tokenNames);
        errors.Add(hdr + " " + msg);
    }
    
    public List<String> GetErrors() {
        return errors;
    }

    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"PLUS", 
		"MINUS", 
		"MULT", 
		"DIV", 
		"ASSIGNMENT", 
		"PLUS_ASSIGNMENT", 
		"MINUS_ASSIGNMENT", 
		"PLUS_PLUS", 
		"MINUS_MINUS", 
		"SEMICOLON", 
		"LEFT_PARENTHESIS", 
		"RIGHT_PARENTHESIS", 
		"COMMA", 
		"LEFT_BRACKET", 
		"RIGHT_BRACKET", 
		"HVIS", 
		"ELLERSHVIS", 
		"ELLERS", 
		"MENS", 
		"LOOP", 
		"EQUALTO", 
		"NOTEQUALTO", 
		"LARGERTHANEQUALS", 
		"SMALLERTHANEQUALS", 
		"LARGERTHAN", 
		"SMALLERTHAN", 
		"STARTCONVEYER", 
		"STOPCONVEYER", 
		"INIT", 
		"HOME", 
		"MOVE_TO_WEIGHT", 
		"MOVE_TO_CONVEYER", 
		"MOVE_TO_SORTBOX", 
		"GRAP_BRICK", 
		"RELEASE_BRICK", 
		"MEASURE_BRICK", 
		"WEIGH_BRICK", 
		"ROLL_GRAPPER_RIGHT", 
		"ROLL_GRAPPER_LEFT", 
		"PITCH_GRAPPER_UP", 
		"PITCH_GRAPPER_DOWN", 
		"MOVE_TO", 
		"MOVE_TO_VECTOR", 
		"ASSIGN_VECTOR", 
		"VARIABLE", 
		"INTEGER", 
		"VECTOR", 
		"NUMBER", 
		"IDENTIFIER", 
		"LETTER", 
		"DIGIT", 
		"WHITESPACE", 
		"LOWER", 
		"UPPER"
    };

    public const int MOVE_TO_VECTOR = 46;
    public const int MOVE_TO_CONVEYER = 35;
    public const int STOPCONVEYER = 31;
    public const int SMALLERTHANEQUALS = 27;
    public const int LETTER = 53;
    public const int PITCH_GRAPPER_DOWN = 44;
    public const int LEFT_BRACKET = 17;
    public const int ELLERSHVIS = 20;
    public const int LARGERTHANEQUALS = 26;
    public const int EQUALTO = 24;
    public const int LARGERTHAN = 28;
    public const int EOF = -1;
    public const int PLUS_PLUS = 11;
    public const int RIGHT_PARENTHESIS = 15;
    public const int COMMA = 16;
    public const int IDENTIFIER = 52;
    public const int LEFT_PARENTHESIS = 14;
    public const int LOOP = 23;
    public const int RIGHT_BRACKET = 18;
    public const int ELLERS = 21;
    public const int PLUS = 4;
    public const int ROLL_GRAPPER_LEFT = 42;
    public const int DIGIT = 54;
    public const int MINUS_ASSIGNMENT = 10;
    public const int MOVE_TO = 45;
    public const int GRAP_BRICK = 37;
    public const int INTEGER = 49;
    public const int PLUS_ASSIGNMENT = 9;
    public const int STARTCONVEYER = 30;
    public const int MEASURE_BRICK = 39;
    public const int PITCH_GRAPPER_UP = 43;
    public const int NUMBER = 51;
    public const int WHITESPACE = 55;
    public const int SEMICOLON = 13;
    public const int MINUS = 5;
    public const int MULT = 6;
    public const int HVIS = 19;
    public const int WEIGH_BRICK = 40;
    public const int SMALLERTHAN = 29;
    public const int MOVE_TO_WEIGHT = 34;
    public const int VARIABLE = 48;
    public const int VECTOR = 50;
    public const int ROLL_GRAPPER_RIGHT = 41;
    public const int MENS = 22;
    public const int HOME = 33;
    public const int ASSIGNMENT = 8;
    public const int RELEASE_BRICK = 38;
    public const int LOWER = 56;
    public const int DIV = 7;
    public const int NOTEQUALTO = 25;
    public const int INIT = 32;
    public const int MOVE_TO_SORTBOX = 36;
    public const int UPPER = 57;
    public const int MINUS_MINUS = 12;
    public const int ASSIGN_VECTOR = 47;

    // delegates
    // delegators



        public DSLParser(ITokenStream input)
    		: this(input, new RecognizerSharedState()) {
        }

        public DSLParser(ITokenStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();

             
        }
        
    protected ITreeAdaptor adaptor = new CommonTreeAdaptor();

    public ITreeAdaptor TreeAdaptor
    {
        get { return this.adaptor; }
        set {
    	this.adaptor = value;
    	}
    }

    override public string[] TokenNames {
		get { return DSLParser.tokenNames; }
    }

    override public string GrammarFileName {
		get { return "C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g"; }
    }


    public class expr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "expr"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:1: expr : ( value | lvalue ) ( EQUALTO | NOTEQUALTO | LARGERTHANEQUALS | SMALLERTHANEQUALS | LARGERTHAN | SMALLERTHAN ) ( value | rvalue ) ;
    public DSLParser.expr_return expr() // throws RecognitionException [1]
    {   
        DSLParser.expr_return retval = new DSLParser.expr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken EQUALTO3 = null;
        IToken NOTEQUALTO4 = null;
        IToken LARGERTHANEQUALS5 = null;
        IToken SMALLERTHANEQUALS6 = null;
        IToken LARGERTHAN7 = null;
        IToken SMALLERTHAN8 = null;
        DSLParser.value_return value1 = default(DSLParser.value_return);

        DSLParser.lvalue_return lvalue2 = default(DSLParser.lvalue_return);

        DSLParser.value_return value9 = default(DSLParser.value_return);

        DSLParser.rvalue_return rvalue10 = default(DSLParser.rvalue_return);


        CommonTree EQUALTO3_tree=null;
        CommonTree NOTEQUALTO4_tree=null;
        CommonTree LARGERTHANEQUALS5_tree=null;
        CommonTree SMALLERTHANEQUALS6_tree=null;
        CommonTree LARGERTHAN7_tree=null;
        CommonTree SMALLERTHAN8_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:6: ( ( value | lvalue ) ( EQUALTO | NOTEQUALTO | LARGERTHANEQUALS | SMALLERTHANEQUALS | LARGERTHAN | SMALLERTHAN ) ( value | rvalue ) )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:8: ( value | lvalue ) ( EQUALTO | NOTEQUALTO | LARGERTHANEQUALS | SMALLERTHANEQUALS | LARGERTHAN | SMALLERTHAN ) ( value | rvalue )
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:8: ( value | lvalue )
            	int alt1 = 2;
            	int LA1_0 = input.LA(1);

            	if ( (LA1_0 == NUMBER) )
            	{
            	    alt1 = 1;
            	}
            	else if ( (LA1_0 == IDENTIFIER) )
            	{
            	    alt1 = 2;
            	}
            	else 
            	{
            	    NoViableAltException nvae_d1s0 =
            	        new NoViableAltException("", 1, 0, input);

            	    throw nvae_d1s0;
            	}
            	switch (alt1) 
            	{
            	    case 1 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:10: value
            	        {
            	        	PushFollow(FOLLOW_value_in_expr459);
            	        	value1 = value();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, value1.Tree);

            	        }
            	        break;
            	    case 2 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:18: lvalue
            	        {
            	        	PushFollow(FOLLOW_lvalue_in_expr463);
            	        	lvalue2 = lvalue();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, lvalue2.Tree);

            	        }
            	        break;

            	}

            	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:27: ( EQUALTO | NOTEQUALTO | LARGERTHANEQUALS | SMALLERTHANEQUALS | LARGERTHAN | SMALLERTHAN )
            	int alt2 = 6;
            	switch ( input.LA(1) ) 
            	{
            	case EQUALTO:
            		{
            	    alt2 = 1;
            	    }
            	    break;
            	case NOTEQUALTO:
            		{
            	    alt2 = 2;
            	    }
            	    break;
            	case LARGERTHANEQUALS:
            		{
            	    alt2 = 3;
            	    }
            	    break;
            	case SMALLERTHANEQUALS:
            		{
            	    alt2 = 4;
            	    }
            	    break;
            	case LARGERTHAN:
            		{
            	    alt2 = 5;
            	    }
            	    break;
            	case SMALLERTHAN:
            		{
            	    alt2 = 6;
            	    }
            	    break;
            		default:
            		    NoViableAltException nvae_d2s0 =
            		        new NoViableAltException("", 2, 0, input);

            		    throw nvae_d2s0;
            	}

            	switch (alt2) 
            	{
            	    case 1 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:29: EQUALTO
            	        {
            	        	EQUALTO3=(IToken)Match(input,EQUALTO,FOLLOW_EQUALTO_in_expr469); 
            	        		EQUALTO3_tree = (CommonTree)adaptor.Create(EQUALTO3);
            	        		root_0 = (CommonTree)adaptor.BecomeRoot(EQUALTO3_tree, root_0);


            	        }
            	        break;
            	    case 2 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:40: NOTEQUALTO
            	        {
            	        	NOTEQUALTO4=(IToken)Match(input,NOTEQUALTO,FOLLOW_NOTEQUALTO_in_expr474); 
            	        		NOTEQUALTO4_tree = (CommonTree)adaptor.Create(NOTEQUALTO4);
            	        		root_0 = (CommonTree)adaptor.BecomeRoot(NOTEQUALTO4_tree, root_0);


            	        }
            	        break;
            	    case 3 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:54: LARGERTHANEQUALS
            	        {
            	        	LARGERTHANEQUALS5=(IToken)Match(input,LARGERTHANEQUALS,FOLLOW_LARGERTHANEQUALS_in_expr479); 
            	        		LARGERTHANEQUALS5_tree = (CommonTree)adaptor.Create(LARGERTHANEQUALS5);
            	        		root_0 = (CommonTree)adaptor.BecomeRoot(LARGERTHANEQUALS5_tree, root_0);


            	        }
            	        break;
            	    case 4 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:74: SMALLERTHANEQUALS
            	        {
            	        	SMALLERTHANEQUALS6=(IToken)Match(input,SMALLERTHANEQUALS,FOLLOW_SMALLERTHANEQUALS_in_expr484); 
            	        		SMALLERTHANEQUALS6_tree = (CommonTree)adaptor.Create(SMALLERTHANEQUALS6);
            	        		root_0 = (CommonTree)adaptor.BecomeRoot(SMALLERTHANEQUALS6_tree, root_0);


            	        }
            	        break;
            	    case 5 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:95: LARGERTHAN
            	        {
            	        	LARGERTHAN7=(IToken)Match(input,LARGERTHAN,FOLLOW_LARGERTHAN_in_expr489); 
            	        		LARGERTHAN7_tree = (CommonTree)adaptor.Create(LARGERTHAN7);
            	        		root_0 = (CommonTree)adaptor.BecomeRoot(LARGERTHAN7_tree, root_0);


            	        }
            	        break;
            	    case 6 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:109: SMALLERTHAN
            	        {
            	        	SMALLERTHAN8=(IToken)Match(input,SMALLERTHAN,FOLLOW_SMALLERTHAN_in_expr494); 
            	        		SMALLERTHAN8_tree = (CommonTree)adaptor.Create(SMALLERTHAN8);
            	        		root_0 = (CommonTree)adaptor.BecomeRoot(SMALLERTHAN8_tree, root_0);


            	        }
            	        break;

            	}

            	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:125: ( value | rvalue )
            	int alt3 = 2;
            	int LA3_0 = input.LA(1);

            	if ( (LA3_0 == NUMBER) )
            	{
            	    alt3 = 1;
            	}
            	else if ( (LA3_0 == IDENTIFIER) )
            	{
            	    alt3 = 2;
            	}
            	else 
            	{
            	    NoViableAltException nvae_d3s0 =
            	        new NoViableAltException("", 3, 0, input);

            	    throw nvae_d3s0;
            	}
            	switch (alt3) 
            	{
            	    case 1 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:127: value
            	        {
            	        	PushFollow(FOLLOW_value_in_expr502);
            	        	value9 = value();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, value9.Tree);

            	        }
            	        break;
            	    case 2 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:67:135: rvalue
            	        {
            	        	PushFollow(FOLLOW_rvalue_in_expr506);
            	        	rvalue10 = rvalue();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, rvalue10.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "expr"

    public class mathexpr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "mathexpr"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:69:1: mathexpr : term ( ( PLUS | MINUS ) term )* ;
    public DSLParser.mathexpr_return mathexpr() // throws RecognitionException [1]
    {   
        DSLParser.mathexpr_return retval = new DSLParser.mathexpr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken set12 = null;
        DSLParser.term_return term11 = default(DSLParser.term_return);

        DSLParser.term_return term13 = default(DSLParser.term_return);


        CommonTree set12_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:69:9: ( term ( ( PLUS | MINUS ) term )* )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:69:11: term ( ( PLUS | MINUS ) term )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_term_in_mathexpr516);
            	term11 = term();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, term11.Tree);
            	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:69:16: ( ( PLUS | MINUS ) term )*
            	do 
            	{
            	    int alt4 = 2;
            	    int LA4_0 = input.LA(1);

            	    if ( ((LA4_0 >= PLUS && LA4_0 <= MINUS)) )
            	    {
            	        alt4 = 1;
            	    }


            	    switch (alt4) 
            		{
            			case 1 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:69:18: ( PLUS | MINUS ) term
            			    {
            			    	set12=(IToken)input.LT(1);
            			    	set12 = (IToken)input.LT(1);
            			    	if ( (input.LA(1) >= PLUS && input.LA(1) <= MINUS) ) 
            			    	{
            			    	    input.Consume();
            			    	    root_0 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(set12), root_0);
            			    	    state.errorRecovery = false;
            			    	}
            			    	else 
            			    	{
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    throw mse;
            			    	}

            			    	PushFollow(FOLLOW_term_in_mathexpr532);
            			    	term13 = term();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, term13.Tree);

            			    }
            			    break;

            			default:
            			    goto loop4;
            	    }
            	} while (true);

            	loop4:
            		;	// Stops C# compiler whining that label 'loop4' has no statements


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "mathexpr"

    public class term_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "term"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:71:1: term : ( factor | lvalue ) ( ( MULT | DIV ) ( factor | rvalue ) )* ;
    public DSLParser.term_return term() // throws RecognitionException [1]
    {   
        DSLParser.term_return retval = new DSLParser.term_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken set16 = null;
        DSLParser.factor_return factor14 = default(DSLParser.factor_return);

        DSLParser.lvalue_return lvalue15 = default(DSLParser.lvalue_return);

        DSLParser.factor_return factor17 = default(DSLParser.factor_return);

        DSLParser.rvalue_return rvalue18 = default(DSLParser.rvalue_return);


        CommonTree set16_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:71:6: ( ( factor | lvalue ) ( ( MULT | DIV ) ( factor | rvalue ) )* )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:71:8: ( factor | lvalue ) ( ( MULT | DIV ) ( factor | rvalue ) )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:71:8: ( factor | lvalue )
            	int alt5 = 2;
            	int LA5_0 = input.LA(1);

            	if ( (LA5_0 == NUMBER) )
            	{
            	    alt5 = 1;
            	}
            	else if ( (LA5_0 == IDENTIFIER) )
            	{
            	    alt5 = 2;
            	}
            	else 
            	{
            	    NoViableAltException nvae_d5s0 =
            	        new NoViableAltException("", 5, 0, input);

            	    throw nvae_d5s0;
            	}
            	switch (alt5) 
            	{
            	    case 1 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:71:9: factor
            	        {
            	        	PushFollow(FOLLOW_factor_in_term545);
            	        	factor14 = factor();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, factor14.Tree);

            	        }
            	        break;
            	    case 2 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:71:18: lvalue
            	        {
            	        	PushFollow(FOLLOW_lvalue_in_term549);
            	        	lvalue15 = lvalue();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, lvalue15.Tree);

            	        }
            	        break;

            	}

            	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:71:27: ( ( MULT | DIV ) ( factor | rvalue ) )*
            	do 
            	{
            	    int alt7 = 2;
            	    int LA7_0 = input.LA(1);

            	    if ( ((LA7_0 >= MULT && LA7_0 <= DIV)) )
            	    {
            	        alt7 = 1;
            	    }


            	    switch (alt7) 
            		{
            			case 1 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:71:29: ( MULT | DIV ) ( factor | rvalue )
            			    {
            			    	set16=(IToken)input.LT(1);
            			    	set16 = (IToken)input.LT(1);
            			    	if ( (input.LA(1) >= MULT && input.LA(1) <= DIV) ) 
            			    	{
            			    	    input.Consume();
            			    	    root_0 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(set16), root_0);
            			    	    state.errorRecovery = false;
            			    	}
            			    	else 
            			    	{
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    throw mse;
            			    	}

            			    	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:71:45: ( factor | rvalue )
            			    	int alt6 = 2;
            			    	int LA6_0 = input.LA(1);

            			    	if ( (LA6_0 == NUMBER) )
            			    	{
            			    	    alt6 = 1;
            			    	}
            			    	else if ( (LA6_0 == IDENTIFIER) )
            			    	{
            			    	    alt6 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    NoViableAltException nvae_d6s0 =
            			    	        new NoViableAltException("", 6, 0, input);

            			    	    throw nvae_d6s0;
            			    	}
            			    	switch (alt6) 
            			    	{
            			    	    case 1 :
            			    	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:71:46: factor
            			    	        {
            			    	        	PushFollow(FOLLOW_factor_in_term567);
            			    	        	factor17 = factor();
            			    	        	state.followingStackPointer--;

            			    	        	adaptor.AddChild(root_0, factor17.Tree);

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:71:55: rvalue
            			    	        {
            			    	        	PushFollow(FOLLOW_rvalue_in_term571);
            			    	        	rvalue18 = rvalue();
            			    	        	state.followingStackPointer--;

            			    	        	adaptor.AddChild(root_0, rvalue18.Tree);

            			    	        }
            			    	        break;

            			    	}


            			    }
            			    break;

            			default:
            			    goto loop7;
            	    }
            	} while (true);

            	loop7:
            		;	// Stops C# compiler whining that label 'loop7' has no statements


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "term"

    public class factor_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "factor"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:73:1: factor : NUMBER ;
    public DSLParser.factor_return factor() // throws RecognitionException [1]
    {   
        DSLParser.factor_return retval = new DSLParser.factor_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken NUMBER19 = null;

        CommonTree NUMBER19_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:73:8: ( NUMBER )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:73:10: NUMBER
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	NUMBER19=(IToken)Match(input,NUMBER,FOLLOW_NUMBER_in_factor584); 
            		NUMBER19_tree = (CommonTree)adaptor.Create(NUMBER19);
            		adaptor.AddChild(root_0, NUMBER19_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "factor"

    public class program_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "program"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:75:1: program : initialization functions ;
    public DSLParser.program_return program() // throws RecognitionException [1]
    {   
        DSLParser.program_return retval = new DSLParser.program_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        DSLParser.initialization_return initialization20 = default(DSLParser.initialization_return);

        DSLParser.functions_return functions21 = default(DSLParser.functions_return);



        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:75:9: ( initialization functions )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:76:2: initialization functions
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_initialization_in_program595);
            	initialization20 = initialization();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, initialization20.Tree);
            	PushFollow(FOLLOW_functions_in_program597);
            	functions21 = functions();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, functions21.Tree);

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "program"

    public class functions_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "functions"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:78:1: functions : ( STARTCONVEYER | STOPCONVEYER | MOVE_TO_WEIGHT | RELEASE_BRICK | WEIGH_BRICK | MOVE_TO_CONVEYER | MOVE_TO_SORTBOX | GRAP_BRICK | MEASURE_BRICK | rollgrapperR | rollgrapperL | pitchgrapperU | pitchgrapperD | declaration | statements | hvis ( ellershvis )* ( ellers )? | mens | loop | moveTo | vectorassignment )* ;
    public DSLParser.functions_return functions() // throws RecognitionException [1]
    {   
        DSLParser.functions_return retval = new DSLParser.functions_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken STARTCONVEYER22 = null;
        IToken STOPCONVEYER23 = null;
        IToken MOVE_TO_WEIGHT24 = null;
        IToken RELEASE_BRICK25 = null;
        IToken WEIGH_BRICK26 = null;
        IToken MOVE_TO_CONVEYER27 = null;
        IToken MOVE_TO_SORTBOX28 = null;
        IToken GRAP_BRICK29 = null;
        IToken MEASURE_BRICK30 = null;
        DSLParser.rollgrapperR_return rollgrapperR31 = default(DSLParser.rollgrapperR_return);

        DSLParser.rollgrapperL_return rollgrapperL32 = default(DSLParser.rollgrapperL_return);

        DSLParser.pitchgrapperU_return pitchgrapperU33 = default(DSLParser.pitchgrapperU_return);

        DSLParser.pitchgrapperD_return pitchgrapperD34 = default(DSLParser.pitchgrapperD_return);

        DSLParser.declaration_return declaration35 = default(DSLParser.declaration_return);

        DSLParser.statements_return statements36 = default(DSLParser.statements_return);

        DSLParser.hvis_return hvis37 = default(DSLParser.hvis_return);

        DSLParser.ellershvis_return ellershvis38 = default(DSLParser.ellershvis_return);

        DSLParser.ellers_return ellers39 = default(DSLParser.ellers_return);

        DSLParser.mens_return mens40 = default(DSLParser.mens_return);

        DSLParser.loop_return loop41 = default(DSLParser.loop_return);

        DSLParser.moveTo_return moveTo42 = default(DSLParser.moveTo_return);

        DSLParser.vectorassignment_return vectorassignment43 = default(DSLParser.vectorassignment_return);


        CommonTree STARTCONVEYER22_tree=null;
        CommonTree STOPCONVEYER23_tree=null;
        CommonTree MOVE_TO_WEIGHT24_tree=null;
        CommonTree RELEASE_BRICK25_tree=null;
        CommonTree WEIGH_BRICK26_tree=null;
        CommonTree MOVE_TO_CONVEYER27_tree=null;
        CommonTree MOVE_TO_SORTBOX28_tree=null;
        CommonTree GRAP_BRICK29_tree=null;
        CommonTree MEASURE_BRICK30_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:79:2: ( ( STARTCONVEYER | STOPCONVEYER | MOVE_TO_WEIGHT | RELEASE_BRICK | WEIGH_BRICK | MOVE_TO_CONVEYER | MOVE_TO_SORTBOX | GRAP_BRICK | MEASURE_BRICK | rollgrapperR | rollgrapperL | pitchgrapperU | pitchgrapperD | declaration | statements | hvis ( ellershvis )* ( ellers )? | mens | loop | moveTo | vectorassignment )* )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:80:2: ( STARTCONVEYER | STOPCONVEYER | MOVE_TO_WEIGHT | RELEASE_BRICK | WEIGH_BRICK | MOVE_TO_CONVEYER | MOVE_TO_SORTBOX | GRAP_BRICK | MEASURE_BRICK | rollgrapperR | rollgrapperL | pitchgrapperU | pitchgrapperD | declaration | statements | hvis ( ellershvis )* ( ellers )? | mens | loop | moveTo | vectorassignment )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:80:2: ( STARTCONVEYER | STOPCONVEYER | MOVE_TO_WEIGHT | RELEASE_BRICK | WEIGH_BRICK | MOVE_TO_CONVEYER | MOVE_TO_SORTBOX | GRAP_BRICK | MEASURE_BRICK | rollgrapperR | rollgrapperL | pitchgrapperU | pitchgrapperD | declaration | statements | hvis ( ellershvis )* ( ellers )? | mens | loop | moveTo | vectorassignment )*
            	do 
            	{
            	    int alt10 = 21;
            	    switch ( input.LA(1) ) 
            	    {
            	    case STARTCONVEYER:
            	    	{
            	        alt10 = 1;
            	        }
            	        break;
            	    case STOPCONVEYER:
            	    	{
            	        alt10 = 2;
            	        }
            	        break;
            	    case MOVE_TO_WEIGHT:
            	    	{
            	        alt10 = 3;
            	        }
            	        break;
            	    case RELEASE_BRICK:
            	    	{
            	        alt10 = 4;
            	        }
            	        break;
            	    case WEIGH_BRICK:
            	    	{
            	        alt10 = 5;
            	        }
            	        break;
            	    case MOVE_TO_CONVEYER:
            	    	{
            	        alt10 = 6;
            	        }
            	        break;
            	    case MOVE_TO_SORTBOX:
            	    	{
            	        alt10 = 7;
            	        }
            	        break;
            	    case GRAP_BRICK:
            	    	{
            	        alt10 = 8;
            	        }
            	        break;
            	    case MEASURE_BRICK:
            	    	{
            	        alt10 = 9;
            	        }
            	        break;
            	    case ROLL_GRAPPER_RIGHT:
            	    	{
            	        alt10 = 10;
            	        }
            	        break;
            	    case ROLL_GRAPPER_LEFT:
            	    	{
            	        alt10 = 11;
            	        }
            	        break;
            	    case PITCH_GRAPPER_UP:
            	    	{
            	        alt10 = 12;
            	        }
            	        break;
            	    case PITCH_GRAPPER_DOWN:
            	    	{
            	        alt10 = 13;
            	        }
            	        break;
            	    case VARIABLE:
            	    	{
            	        alt10 = 14;
            	        }
            	        break;
            	    case IDENTIFIER:
            	    	{
            	        alt10 = 15;
            	        }
            	        break;
            	    case HVIS:
            	    	{
            	        alt10 = 16;
            	        }
            	        break;
            	    case MENS:
            	    	{
            	        alt10 = 17;
            	        }
            	        break;
            	    case LOOP:
            	    	{
            	        alt10 = 18;
            	        }
            	        break;
            	    case MOVE_TO:
            	    	{
            	        alt10 = 19;
            	        }
            	        break;
            	    case ASSIGN_VECTOR:
            	    	{
            	        alt10 = 20;
            	        }
            	        break;

            	    }

            	    switch (alt10) 
            		{
            			case 1 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:80:4: STARTCONVEYER
            			    {
            			    	STARTCONVEYER22=(IToken)Match(input,STARTCONVEYER,FOLLOW_STARTCONVEYER_in_functions611); 
            			    		STARTCONVEYER22_tree = (CommonTree)adaptor.Create(STARTCONVEYER22);
            			    		adaptor.AddChild(root_0, STARTCONVEYER22_tree);


            			    }
            			    break;
            			case 2 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:81:4: STOPCONVEYER
            			    {
            			    	STOPCONVEYER23=(IToken)Match(input,STOPCONVEYER,FOLLOW_STOPCONVEYER_in_functions616); 
            			    		STOPCONVEYER23_tree = (CommonTree)adaptor.Create(STOPCONVEYER23);
            			    		adaptor.AddChild(root_0, STOPCONVEYER23_tree);


            			    }
            			    break;
            			case 3 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:82:4: MOVE_TO_WEIGHT
            			    {
            			    	MOVE_TO_WEIGHT24=(IToken)Match(input,MOVE_TO_WEIGHT,FOLLOW_MOVE_TO_WEIGHT_in_functions621); 
            			    		MOVE_TO_WEIGHT24_tree = (CommonTree)adaptor.Create(MOVE_TO_WEIGHT24);
            			    		adaptor.AddChild(root_0, MOVE_TO_WEIGHT24_tree);


            			    }
            			    break;
            			case 4 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:83:4: RELEASE_BRICK
            			    {
            			    	RELEASE_BRICK25=(IToken)Match(input,RELEASE_BRICK,FOLLOW_RELEASE_BRICK_in_functions627); 
            			    		RELEASE_BRICK25_tree = (CommonTree)adaptor.Create(RELEASE_BRICK25);
            			    		adaptor.AddChild(root_0, RELEASE_BRICK25_tree);


            			    }
            			    break;
            			case 5 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:84:4: WEIGH_BRICK
            			    {
            			    	WEIGH_BRICK26=(IToken)Match(input,WEIGH_BRICK,FOLLOW_WEIGH_BRICK_in_functions633); 
            			    		WEIGH_BRICK26_tree = (CommonTree)adaptor.Create(WEIGH_BRICK26);
            			    		adaptor.AddChild(root_0, WEIGH_BRICK26_tree);


            			    }
            			    break;
            			case 6 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:85:4: MOVE_TO_CONVEYER
            			    {
            			    	MOVE_TO_CONVEYER27=(IToken)Match(input,MOVE_TO_CONVEYER,FOLLOW_MOVE_TO_CONVEYER_in_functions638); 
            			    		MOVE_TO_CONVEYER27_tree = (CommonTree)adaptor.Create(MOVE_TO_CONVEYER27);
            			    		adaptor.AddChild(root_0, MOVE_TO_CONVEYER27_tree);


            			    }
            			    break;
            			case 7 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:86:4: MOVE_TO_SORTBOX
            			    {
            			    	MOVE_TO_SORTBOX28=(IToken)Match(input,MOVE_TO_SORTBOX,FOLLOW_MOVE_TO_SORTBOX_in_functions643); 
            			    		MOVE_TO_SORTBOX28_tree = (CommonTree)adaptor.Create(MOVE_TO_SORTBOX28);
            			    		adaptor.AddChild(root_0, MOVE_TO_SORTBOX28_tree);


            			    }
            			    break;
            			case 8 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:87:4: GRAP_BRICK
            			    {
            			    	GRAP_BRICK29=(IToken)Match(input,GRAP_BRICK,FOLLOW_GRAP_BRICK_in_functions648); 
            			    		GRAP_BRICK29_tree = (CommonTree)adaptor.Create(GRAP_BRICK29);
            			    		adaptor.AddChild(root_0, GRAP_BRICK29_tree);


            			    }
            			    break;
            			case 9 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:88:4: MEASURE_BRICK
            			    {
            			    	MEASURE_BRICK30=(IToken)Match(input,MEASURE_BRICK,FOLLOW_MEASURE_BRICK_in_functions654); 
            			    		MEASURE_BRICK30_tree = (CommonTree)adaptor.Create(MEASURE_BRICK30);
            			    		adaptor.AddChild(root_0, MEASURE_BRICK30_tree);


            			    }
            			    break;
            			case 10 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:89:4: rollgrapperR
            			    {
            			    	PushFollow(FOLLOW_rollgrapperR_in_functions659);
            			    	rollgrapperR31 = rollgrapperR();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, rollgrapperR31.Tree);

            			    }
            			    break;
            			case 11 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:90:4: rollgrapperL
            			    {
            			    	PushFollow(FOLLOW_rollgrapperL_in_functions664);
            			    	rollgrapperL32 = rollgrapperL();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, rollgrapperL32.Tree);

            			    }
            			    break;
            			case 12 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:91:4: pitchgrapperU
            			    {
            			    	PushFollow(FOLLOW_pitchgrapperU_in_functions669);
            			    	pitchgrapperU33 = pitchgrapperU();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, pitchgrapperU33.Tree);

            			    }
            			    break;
            			case 13 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:92:4: pitchgrapperD
            			    {
            			    	PushFollow(FOLLOW_pitchgrapperD_in_functions674);
            			    	pitchgrapperD34 = pitchgrapperD();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, pitchgrapperD34.Tree);

            			    }
            			    break;
            			case 14 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:93:4: declaration
            			    {
            			    	PushFollow(FOLLOW_declaration_in_functions679);
            			    	declaration35 = declaration();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, declaration35.Tree);

            			    }
            			    break;
            			case 15 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:94:4: statements
            			    {
            			    	PushFollow(FOLLOW_statements_in_functions684);
            			    	statements36 = statements();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, statements36.Tree);

            			    }
            			    break;
            			case 16 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:95:4: hvis ( ellershvis )* ( ellers )?
            			    {
            			    	PushFollow(FOLLOW_hvis_in_functions689);
            			    	hvis37 = hvis();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, hvis37.Tree);
            			    	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:95:9: ( ellershvis )*
            			    	do 
            			    	{
            			    	    int alt8 = 2;
            			    	    int LA8_0 = input.LA(1);

            			    	    if ( (LA8_0 == ELLERSHVIS) )
            			    	    {
            			    	        alt8 = 1;
            			    	    }


            			    	    switch (alt8) 
            			    		{
            			    			case 1 :
            			    			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:95:10: ellershvis
            			    			    {
            			    			    	PushFollow(FOLLOW_ellershvis_in_functions692);
            			    			    	ellershvis38 = ellershvis();
            			    			    	state.followingStackPointer--;

            			    			    	adaptor.AddChild(root_0, ellershvis38.Tree);

            			    			    }
            			    			    break;

            			    			default:
            			    			    goto loop8;
            			    	    }
            			    	} while (true);

            			    	loop8:
            			    		;	// Stops C# compiler whining that label 'loop8' has no statements

            			    	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:95:24: ( ellers )?
            			    	int alt9 = 2;
            			    	int LA9_0 = input.LA(1);

            			    	if ( (LA9_0 == ELLERS) )
            			    	{
            			    	    alt9 = 1;
            			    	}
            			    	switch (alt9) 
            			    	{
            			    	    case 1 :
            			    	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:95:24: ellers
            			    	        {
            			    	        	PushFollow(FOLLOW_ellers_in_functions697);
            			    	        	ellers39 = ellers();
            			    	        	state.followingStackPointer--;

            			    	        	adaptor.AddChild(root_0, ellers39.Tree);

            			    	        }
            			    	        break;

            			    	}


            			    }
            			    break;
            			case 17 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:96:4: mens
            			    {
            			    	PushFollow(FOLLOW_mens_in_functions703);
            			    	mens40 = mens();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, mens40.Tree);

            			    }
            			    break;
            			case 18 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:97:4: loop
            			    {
            			    	PushFollow(FOLLOW_loop_in_functions708);
            			    	loop41 = loop();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, loop41.Tree);

            			    }
            			    break;
            			case 19 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:98:4: moveTo
            			    {
            			    	PushFollow(FOLLOW_moveTo_in_functions713);
            			    	moveTo42 = moveTo();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, moveTo42.Tree);

            			    }
            			    break;
            			case 20 :
            			    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:99:4: vectorassignment
            			    {
            			    	PushFollow(FOLLOW_vectorassignment_in_functions718);
            			    	vectorassignment43 = vectorassignment();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, vectorassignment43.Tree);

            			    }
            			    break;

            			default:
            			    goto loop10;
            	    }
            	} while (true);

            	loop10:
            		;	// Stops C# compiler whining that label 'loop10' has no statements


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "functions"

    public class rollgrapperR_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "rollgrapperR"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:102:1: rollgrapperR : ROLL_GRAPPER_RIGHT '(' value ')' ;
    public DSLParser.rollgrapperR_return rollgrapperR() // throws RecognitionException [1]
    {   
        DSLParser.rollgrapperR_return retval = new DSLParser.rollgrapperR_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ROLL_GRAPPER_RIGHT44 = null;
        IToken char_literal45 = null;
        IToken char_literal47 = null;
        DSLParser.value_return value46 = default(DSLParser.value_return);


        CommonTree ROLL_GRAPPER_RIGHT44_tree=null;
        CommonTree char_literal45_tree=null;
        CommonTree char_literal47_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:103:2: ( ROLL_GRAPPER_RIGHT '(' value ')' )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:103:4: ROLL_GRAPPER_RIGHT '(' value ')'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	ROLL_GRAPPER_RIGHT44=(IToken)Match(input,ROLL_GRAPPER_RIGHT,FOLLOW_ROLL_GRAPPER_RIGHT_in_rollgrapperR732); 
            		ROLL_GRAPPER_RIGHT44_tree = (CommonTree)adaptor.Create(ROLL_GRAPPER_RIGHT44);
            		root_0 = (CommonTree)adaptor.BecomeRoot(ROLL_GRAPPER_RIGHT44_tree, root_0);

            	char_literal45=(IToken)Match(input,LEFT_PARENTHESIS,FOLLOW_LEFT_PARENTHESIS_in_rollgrapperR735); 
            	PushFollow(FOLLOW_value_in_rollgrapperR738);
            	value46 = value();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, value46.Tree);
            	char_literal47=(IToken)Match(input,RIGHT_PARENTHESIS,FOLLOW_RIGHT_PARENTHESIS_in_rollgrapperR740); 

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "rollgrapperR"

    public class rollgrapperL_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "rollgrapperL"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:105:1: rollgrapperL : ROLL_GRAPPER_LEFT '(' value ')' ;
    public DSLParser.rollgrapperL_return rollgrapperL() // throws RecognitionException [1]
    {   
        DSLParser.rollgrapperL_return retval = new DSLParser.rollgrapperL_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ROLL_GRAPPER_LEFT48 = null;
        IToken char_literal49 = null;
        IToken char_literal51 = null;
        DSLParser.value_return value50 = default(DSLParser.value_return);


        CommonTree ROLL_GRAPPER_LEFT48_tree=null;
        CommonTree char_literal49_tree=null;
        CommonTree char_literal51_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:106:2: ( ROLL_GRAPPER_LEFT '(' value ')' )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:106:4: ROLL_GRAPPER_LEFT '(' value ')'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	ROLL_GRAPPER_LEFT48=(IToken)Match(input,ROLL_GRAPPER_LEFT,FOLLOW_ROLL_GRAPPER_LEFT_in_rollgrapperL751); 
            		ROLL_GRAPPER_LEFT48_tree = (CommonTree)adaptor.Create(ROLL_GRAPPER_LEFT48);
            		root_0 = (CommonTree)adaptor.BecomeRoot(ROLL_GRAPPER_LEFT48_tree, root_0);

            	char_literal49=(IToken)Match(input,LEFT_PARENTHESIS,FOLLOW_LEFT_PARENTHESIS_in_rollgrapperL754); 
            	PushFollow(FOLLOW_value_in_rollgrapperL757);
            	value50 = value();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, value50.Tree);
            	char_literal51=(IToken)Match(input,RIGHT_PARENTHESIS,FOLLOW_RIGHT_PARENTHESIS_in_rollgrapperL759); 

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "rollgrapperL"

    public class pitchgrapperU_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "pitchgrapperU"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:108:1: pitchgrapperU : PITCH_GRAPPER_UP '(' value ')' ;
    public DSLParser.pitchgrapperU_return pitchgrapperU() // throws RecognitionException [1]
    {   
        DSLParser.pitchgrapperU_return retval = new DSLParser.pitchgrapperU_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken PITCH_GRAPPER_UP52 = null;
        IToken char_literal53 = null;
        IToken char_literal55 = null;
        DSLParser.value_return value54 = default(DSLParser.value_return);


        CommonTree PITCH_GRAPPER_UP52_tree=null;
        CommonTree char_literal53_tree=null;
        CommonTree char_literal55_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:109:2: ( PITCH_GRAPPER_UP '(' value ')' )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:109:4: PITCH_GRAPPER_UP '(' value ')'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PITCH_GRAPPER_UP52=(IToken)Match(input,PITCH_GRAPPER_UP,FOLLOW_PITCH_GRAPPER_UP_in_pitchgrapperU770); 
            		PITCH_GRAPPER_UP52_tree = (CommonTree)adaptor.Create(PITCH_GRAPPER_UP52);
            		root_0 = (CommonTree)adaptor.BecomeRoot(PITCH_GRAPPER_UP52_tree, root_0);

            	char_literal53=(IToken)Match(input,LEFT_PARENTHESIS,FOLLOW_LEFT_PARENTHESIS_in_pitchgrapperU773); 
            	PushFollow(FOLLOW_value_in_pitchgrapperU776);
            	value54 = value();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, value54.Tree);
            	char_literal55=(IToken)Match(input,RIGHT_PARENTHESIS,FOLLOW_RIGHT_PARENTHESIS_in_pitchgrapperU778); 

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "pitchgrapperU"

    public class pitchgrapperD_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "pitchgrapperD"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:111:1: pitchgrapperD : PITCH_GRAPPER_DOWN '(' value ')' ;
    public DSLParser.pitchgrapperD_return pitchgrapperD() // throws RecognitionException [1]
    {   
        DSLParser.pitchgrapperD_return retval = new DSLParser.pitchgrapperD_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken PITCH_GRAPPER_DOWN56 = null;
        IToken char_literal57 = null;
        IToken char_literal59 = null;
        DSLParser.value_return value58 = default(DSLParser.value_return);


        CommonTree PITCH_GRAPPER_DOWN56_tree=null;
        CommonTree char_literal57_tree=null;
        CommonTree char_literal59_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:112:2: ( PITCH_GRAPPER_DOWN '(' value ')' )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:112:4: PITCH_GRAPPER_DOWN '(' value ')'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PITCH_GRAPPER_DOWN56=(IToken)Match(input,PITCH_GRAPPER_DOWN,FOLLOW_PITCH_GRAPPER_DOWN_in_pitchgrapperD790); 
            		PITCH_GRAPPER_DOWN56_tree = (CommonTree)adaptor.Create(PITCH_GRAPPER_DOWN56);
            		root_0 = (CommonTree)adaptor.BecomeRoot(PITCH_GRAPPER_DOWN56_tree, root_0);

            	char_literal57=(IToken)Match(input,LEFT_PARENTHESIS,FOLLOW_LEFT_PARENTHESIS_in_pitchgrapperD793); 
            	PushFollow(FOLLOW_value_in_pitchgrapperD796);
            	value58 = value();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, value58.Tree);
            	char_literal59=(IToken)Match(input,RIGHT_PARENTHESIS,FOLLOW_RIGHT_PARENTHESIS_in_pitchgrapperD798); 

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "pitchgrapperD"

    public class moveTo_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "moveTo"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:114:1: moveTo : MOVE_TO '(' ( ( value ',' value ',' value ',' value ',' value ) | lvalue ) ')' ;
    public DSLParser.moveTo_return moveTo() // throws RecognitionException [1]
    {   
        DSLParser.moveTo_return retval = new DSLParser.moveTo_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken MOVE_TO60 = null;
        IToken char_literal61 = null;
        IToken char_literal63 = null;
        IToken char_literal65 = null;
        IToken char_literal67 = null;
        IToken char_literal69 = null;
        IToken char_literal72 = null;
        DSLParser.value_return value62 = default(DSLParser.value_return);

        DSLParser.value_return value64 = default(DSLParser.value_return);

        DSLParser.value_return value66 = default(DSLParser.value_return);

        DSLParser.value_return value68 = default(DSLParser.value_return);

        DSLParser.value_return value70 = default(DSLParser.value_return);

        DSLParser.lvalue_return lvalue71 = default(DSLParser.lvalue_return);


        CommonTree MOVE_TO60_tree=null;
        CommonTree char_literal61_tree=null;
        CommonTree char_literal63_tree=null;
        CommonTree char_literal65_tree=null;
        CommonTree char_literal67_tree=null;
        CommonTree char_literal69_tree=null;
        CommonTree char_literal72_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:114:8: ( MOVE_TO '(' ( ( value ',' value ',' value ',' value ',' value ) | lvalue ) ')' )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:114:10: MOVE_TO '(' ( ( value ',' value ',' value ',' value ',' value ) | lvalue ) ')'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	MOVE_TO60=(IToken)Match(input,MOVE_TO,FOLLOW_MOVE_TO_in_moveTo808); 
            		MOVE_TO60_tree = (CommonTree)adaptor.Create(MOVE_TO60);
            		root_0 = (CommonTree)adaptor.BecomeRoot(MOVE_TO60_tree, root_0);

            	char_literal61=(IToken)Match(input,LEFT_PARENTHESIS,FOLLOW_LEFT_PARENTHESIS_in_moveTo811); 
            	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:114:24: ( ( value ',' value ',' value ',' value ',' value ) | lvalue )
            	int alt11 = 2;
            	int LA11_0 = input.LA(1);

            	if ( (LA11_0 == NUMBER) )
            	{
            	    alt11 = 1;
            	}
            	else if ( (LA11_0 == IDENTIFIER) )
            	{
            	    alt11 = 2;
            	}
            	else 
            	{
            	    NoViableAltException nvae_d11s0 =
            	        new NoViableAltException("", 11, 0, input);

            	    throw nvae_d11s0;
            	}
            	switch (alt11) 
            	{
            	    case 1 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:114:25: ( value ',' value ',' value ',' value ',' value )
            	        {
            	        	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:114:25: ( value ',' value ',' value ',' value ',' value )
            	        	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:114:26: value ',' value ',' value ',' value ',' value
            	        	{
            	        		PushFollow(FOLLOW_value_in_moveTo816);
            	        		value62 = value();
            	        		state.followingStackPointer--;

            	        		adaptor.AddChild(root_0, value62.Tree);
            	        		char_literal63=(IToken)Match(input,COMMA,FOLLOW_COMMA_in_moveTo818); 
            	        		PushFollow(FOLLOW_value_in_moveTo821);
            	        		value64 = value();
            	        		state.followingStackPointer--;

            	        		adaptor.AddChild(root_0, value64.Tree);
            	        		char_literal65=(IToken)Match(input,COMMA,FOLLOW_COMMA_in_moveTo823); 
            	        		PushFollow(FOLLOW_value_in_moveTo826);
            	        		value66 = value();
            	        		state.followingStackPointer--;

            	        		adaptor.AddChild(root_0, value66.Tree);
            	        		char_literal67=(IToken)Match(input,COMMA,FOLLOW_COMMA_in_moveTo828); 
            	        		PushFollow(FOLLOW_value_in_moveTo831);
            	        		value68 = value();
            	        		state.followingStackPointer--;

            	        		adaptor.AddChild(root_0, value68.Tree);
            	        		char_literal69=(IToken)Match(input,COMMA,FOLLOW_COMMA_in_moveTo833); 
            	        		PushFollow(FOLLOW_value_in_moveTo836);
            	        		value70 = value();
            	        		state.followingStackPointer--;

            	        		adaptor.AddChild(root_0, value70.Tree);

            	        	}


            	        }
            	        break;
            	    case 2 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:114:79: lvalue
            	        {
            	        	PushFollow(FOLLOW_lvalue_in_moveTo841);
            	        	lvalue71 = lvalue();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, lvalue71.Tree);

            	        }
            	        break;

            	}

            	char_literal72=(IToken)Match(input,RIGHT_PARENTHESIS,FOLLOW_RIGHT_PARENTHESIS_in_moveTo844); 

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "moveTo"

    public class initialization_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "initialization"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:116:1: initialization : init home ;
    public DSLParser.initialization_return initialization() // throws RecognitionException [1]
    {   
        DSLParser.initialization_return retval = new DSLParser.initialization_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        DSLParser.init_return init73 = default(DSLParser.init_return);

        DSLParser.home_return home74 = default(DSLParser.home_return);



        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:117:2: ( init home )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:117:5: init home
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_init_in_initialization856);
            	init73 = init();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, init73.Tree);
            	PushFollow(FOLLOW_home_in_initialization858);
            	home74 = home();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, home74.Tree);

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "initialization"

    public class home_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "home"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:119:1: home : HOME ( '(' )? ( ')' )? ;
    public DSLParser.home_return home() // throws RecognitionException [1]
    {   
        DSLParser.home_return retval = new DSLParser.home_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken HOME75 = null;
        IToken char_literal76 = null;
        IToken char_literal77 = null;

        CommonTree HOME75_tree=null;
        CommonTree char_literal76_tree=null;
        CommonTree char_literal77_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:120:2: ( HOME ( '(' )? ( ')' )? )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:120:5: HOME ( '(' )? ( ')' )?
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	HOME75=(IToken)Match(input,HOME,FOLLOW_HOME_in_home870); 
            		HOME75_tree = (CommonTree)adaptor.Create(HOME75);
            		adaptor.AddChild(root_0, HOME75_tree);

            	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:120:13: ( '(' )?
            	int alt12 = 2;
            	int LA12_0 = input.LA(1);

            	if ( (LA12_0 == LEFT_PARENTHESIS) )
            	{
            	    alt12 = 1;
            	}
            	switch (alt12) 
            	{
            	    case 1 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:120:13: '('
            	        {
            	        	char_literal76=(IToken)Match(input,LEFT_PARENTHESIS,FOLLOW_LEFT_PARENTHESIS_in_home872); 

            	        }
            	        break;

            	}

            	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:120:19: ( ')' )?
            	int alt13 = 2;
            	int LA13_0 = input.LA(1);

            	if ( (LA13_0 == RIGHT_PARENTHESIS) )
            	{
            	    alt13 = 1;
            	}
            	switch (alt13) 
            	{
            	    case 1 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:120:19: ')'
            	        {
            	        	char_literal77=(IToken)Match(input,RIGHT_PARENTHESIS,FOLLOW_RIGHT_PARENTHESIS_in_home876); 

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "home"

    public class init_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "init"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:122:1: init : INIT ( '(' )? ( ')' )? ;
    public DSLParser.init_return init() // throws RecognitionException [1]
    {   
        DSLParser.init_return retval = new DSLParser.init_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken INIT78 = null;
        IToken char_literal79 = null;
        IToken char_literal80 = null;

        CommonTree INIT78_tree=null;
        CommonTree char_literal79_tree=null;
        CommonTree char_literal80_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:123:2: ( INIT ( '(' )? ( ')' )? )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:123:5: INIT ( '(' )? ( ')' )?
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	INIT78=(IToken)Match(input,INIT,FOLLOW_INIT_in_init890); 
            		INIT78_tree = (CommonTree)adaptor.Create(INIT78);
            		root_0 = (CommonTree)adaptor.BecomeRoot(INIT78_tree, root_0);

            	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:123:14: ( '(' )?
            	int alt14 = 2;
            	int LA14_0 = input.LA(1);

            	if ( (LA14_0 == LEFT_PARENTHESIS) )
            	{
            	    alt14 = 1;
            	}
            	switch (alt14) 
            	{
            	    case 1 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:123:14: '('
            	        {
            	        	char_literal79=(IToken)Match(input,LEFT_PARENTHESIS,FOLLOW_LEFT_PARENTHESIS_in_init893); 

            	        }
            	        break;

            	}

            	// C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:123:20: ( ')' )?
            	int alt15 = 2;
            	int LA15_0 = input.LA(1);

            	if ( (LA15_0 == RIGHT_PARENTHESIS) )
            	{
            	    alt15 = 1;
            	}
            	switch (alt15) 
            	{
            	    case 1 :
            	        // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:123:20: ')'
            	        {
            	        	char_literal80=(IToken)Match(input,RIGHT_PARENTHESIS,FOLLOW_RIGHT_PARENTHESIS_in_init897); 

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "init"

    public class hvis_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "hvis"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:125:1: hvis : HVIS '(' expr ')' '{' functions '}' ;
    public DSLParser.hvis_return hvis() // throws RecognitionException [1]
    {   
        DSLParser.hvis_return retval = new DSLParser.hvis_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken HVIS81 = null;
        IToken char_literal82 = null;
        IToken char_literal84 = null;
        IToken char_literal85 = null;
        IToken char_literal87 = null;
        DSLParser.expr_return expr83 = default(DSLParser.expr_return);

        DSLParser.functions_return functions86 = default(DSLParser.functions_return);


        CommonTree HVIS81_tree=null;
        CommonTree char_literal82_tree=null;
        CommonTree char_literal84_tree=null;
        CommonTree char_literal85_tree=null;
        CommonTree char_literal87_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:126:2: ( HVIS '(' expr ')' '{' functions '}' )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:126:4: HVIS '(' expr ')' '{' functions '}'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	HVIS81=(IToken)Match(input,HVIS,FOLLOW_HVIS_in_hvis910); 
            		HVIS81_tree = (CommonTree)adaptor.Create(HVIS81);
            		root_0 = (CommonTree)adaptor.BecomeRoot(HVIS81_tree, root_0);

            	char_literal82=(IToken)Match(input,LEFT_PARENTHESIS,FOLLOW_LEFT_PARENTHESIS_in_hvis913); 
            	PushFollow(FOLLOW_expr_in_hvis916);
            	expr83 = expr();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, expr83.Tree);
            	char_literal84=(IToken)Match(input,RIGHT_PARENTHESIS,FOLLOW_RIGHT_PARENTHESIS_in_hvis918); 
            	char_literal85=(IToken)Match(input,LEFT_BRACKET,FOLLOW_LEFT_BRACKET_in_hvis921); 
            	PushFollow(FOLLOW_functions_in_hvis924);
            	functions86 = functions();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, functions86.Tree);
            	char_literal87=(IToken)Match(input,RIGHT_BRACKET,FOLLOW_RIGHT_BRACKET_in_hvis926); 

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "hvis"

    public class ellershvis_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "ellershvis"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:128:1: ellershvis : ELLERSHVIS '(' expr ')' '{' functions '}' ;
    public DSLParser.ellershvis_return ellershvis() // throws RecognitionException [1]
    {   
        DSLParser.ellershvis_return retval = new DSLParser.ellershvis_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ELLERSHVIS88 = null;
        IToken char_literal89 = null;
        IToken char_literal91 = null;
        IToken char_literal92 = null;
        IToken char_literal94 = null;
        DSLParser.expr_return expr90 = default(DSLParser.expr_return);

        DSLParser.functions_return functions93 = default(DSLParser.functions_return);


        CommonTree ELLERSHVIS88_tree=null;
        CommonTree char_literal89_tree=null;
        CommonTree char_literal91_tree=null;
        CommonTree char_literal92_tree=null;
        CommonTree char_literal94_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:129:2: ( ELLERSHVIS '(' expr ')' '{' functions '}' )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:129:5: ELLERSHVIS '(' expr ')' '{' functions '}'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	ELLERSHVIS88=(IToken)Match(input,ELLERSHVIS,FOLLOW_ELLERSHVIS_in_ellershvis940); 
            		ELLERSHVIS88_tree = (CommonTree)adaptor.Create(ELLERSHVIS88);
            		root_0 = (CommonTree)adaptor.BecomeRoot(ELLERSHVIS88_tree, root_0);

            	char_literal89=(IToken)Match(input,LEFT_PARENTHESIS,FOLLOW_LEFT_PARENTHESIS_in_ellershvis943); 
            	PushFollow(FOLLOW_expr_in_ellershvis946);
            	expr90 = expr();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, expr90.Tree);
            	char_literal91=(IToken)Match(input,RIGHT_PARENTHESIS,FOLLOW_RIGHT_PARENTHESIS_in_ellershvis948); 
            	char_literal92=(IToken)Match(input,LEFT_BRACKET,FOLLOW_LEFT_BRACKET_in_ellershvis951); 
            	PushFollow(FOLLOW_functions_in_ellershvis954);
            	functions93 = functions();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, functions93.Tree);
            	char_literal94=(IToken)Match(input,RIGHT_BRACKET,FOLLOW_RIGHT_BRACKET_in_ellershvis956); 

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "ellershvis"

    public class ellers_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "ellers"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:131:1: ellers : ELLERS '{' functions '}' ;
    public DSLParser.ellers_return ellers() // throws RecognitionException [1]
    {   
        DSLParser.ellers_return retval = new DSLParser.ellers_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ELLERS95 = null;
        IToken char_literal96 = null;
        IToken char_literal98 = null;
        DSLParser.functions_return functions97 = default(DSLParser.functions_return);


        CommonTree ELLERS95_tree=null;
        CommonTree char_literal96_tree=null;
        CommonTree char_literal98_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:132:2: ( ELLERS '{' functions '}' )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:132:4: ELLERS '{' functions '}'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	ELLERS95=(IToken)Match(input,ELLERS,FOLLOW_ELLERS_in_ellers969); 
            		ELLERS95_tree = (CommonTree)adaptor.Create(ELLERS95);
            		root_0 = (CommonTree)adaptor.BecomeRoot(ELLERS95_tree, root_0);

            	char_literal96=(IToken)Match(input,LEFT_BRACKET,FOLLOW_LEFT_BRACKET_in_ellers972); 
            	PushFollow(FOLLOW_functions_in_ellers975);
            	functions97 = functions();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, functions97.Tree);
            	char_literal98=(IToken)Match(input,RIGHT_BRACKET,FOLLOW_RIGHT_BRACKET_in_ellers977); 

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "ellers"

    public class mens_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "mens"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:134:1: mens : MENS '(' expr ')' '{' functions '}' ;
    public DSLParser.mens_return mens() // throws RecognitionException [1]
    {   
        DSLParser.mens_return retval = new DSLParser.mens_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken MENS99 = null;
        IToken char_literal100 = null;
        IToken char_literal102 = null;
        IToken char_literal103 = null;
        IToken char_literal105 = null;
        DSLParser.expr_return expr101 = default(DSLParser.expr_return);

        DSLParser.functions_return functions104 = default(DSLParser.functions_return);


        CommonTree MENS99_tree=null;
        CommonTree char_literal100_tree=null;
        CommonTree char_literal102_tree=null;
        CommonTree char_literal103_tree=null;
        CommonTree char_literal105_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:135:2: ( MENS '(' expr ')' '{' functions '}' )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:135:4: MENS '(' expr ')' '{' functions '}'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	MENS99=(IToken)Match(input,MENS,FOLLOW_MENS_in_mens989); 
            		MENS99_tree = (CommonTree)adaptor.Create(MENS99);
            		root_0 = (CommonTree)adaptor.BecomeRoot(MENS99_tree, root_0);

            	char_literal100=(IToken)Match(input,LEFT_PARENTHESIS,FOLLOW_LEFT_PARENTHESIS_in_mens992); 
            	PushFollow(FOLLOW_expr_in_mens995);
            	expr101 = expr();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, expr101.Tree);
            	char_literal102=(IToken)Match(input,RIGHT_PARENTHESIS,FOLLOW_RIGHT_PARENTHESIS_in_mens997); 
            	char_literal103=(IToken)Match(input,LEFT_BRACKET,FOLLOW_LEFT_BRACKET_in_mens1000); 
            	PushFollow(FOLLOW_functions_in_mens1003);
            	functions104 = functions();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, functions104.Tree);
            	char_literal105=(IToken)Match(input,RIGHT_BRACKET,FOLLOW_RIGHT_BRACKET_in_mens1005); 

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "mens"

    public class loop_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "loop"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:137:1: loop : LOOP '(' value ')' '{' functions '}' ;
    public DSLParser.loop_return loop() // throws RecognitionException [1]
    {   
        DSLParser.loop_return retval = new DSLParser.loop_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken LOOP106 = null;
        IToken char_literal107 = null;
        IToken char_literal109 = null;
        IToken char_literal110 = null;
        IToken char_literal112 = null;
        DSLParser.value_return value108 = default(DSLParser.value_return);

        DSLParser.functions_return functions111 = default(DSLParser.functions_return);


        CommonTree LOOP106_tree=null;
        CommonTree char_literal107_tree=null;
        CommonTree char_literal109_tree=null;
        CommonTree char_literal110_tree=null;
        CommonTree char_literal112_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:138:2: ( LOOP '(' value ')' '{' functions '}' )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:138:4: LOOP '(' value ')' '{' functions '}'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	LOOP106=(IToken)Match(input,LOOP,FOLLOW_LOOP_in_loop1018); 
            		LOOP106_tree = (CommonTree)adaptor.Create(LOOP106);
            		root_0 = (CommonTree)adaptor.BecomeRoot(LOOP106_tree, root_0);

            	char_literal107=(IToken)Match(input,LEFT_PARENTHESIS,FOLLOW_LEFT_PARENTHESIS_in_loop1021); 
            	PushFollow(FOLLOW_value_in_loop1024);
            	value108 = value();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, value108.Tree);
            	char_literal109=(IToken)Match(input,RIGHT_PARENTHESIS,FOLLOW_RIGHT_PARENTHESIS_in_loop1026); 
            	char_literal110=(IToken)Match(input,LEFT_BRACKET,FOLLOW_LEFT_BRACKET_in_loop1029); 
            	PushFollow(FOLLOW_functions_in_loop1032);
            	functions111 = functions();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, functions111.Tree);
            	char_literal112=(IToken)Match(input,RIGHT_BRACKET,FOLLOW_RIGHT_BRACKET_in_loop1034); 

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "loop"

    public class value_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "value"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:140:1: value : NUMBER ;
    public DSLParser.value_return value() // throws RecognitionException [1]
    {   
        DSLParser.value_return retval = new DSLParser.value_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken NUMBER113 = null;

        CommonTree NUMBER113_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:141:2: ( NUMBER )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:141:5: NUMBER
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	NUMBER113=(IToken)Match(input,NUMBER,FOLLOW_NUMBER_in_value1047); 
            		NUMBER113_tree = (CommonTree)adaptor.Create(NUMBER113);
            		adaptor.AddChild(root_0, NUMBER113_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "value"

    public class type_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "type"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:143:1: type : ( INTEGER | VECTOR );
    public DSLParser.type_return type() // throws RecognitionException [1]
    {   
        DSLParser.type_return retval = new DSLParser.type_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken set114 = null;

        CommonTree set114_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:144:2: ( INTEGER | VECTOR )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	set114 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= INTEGER && input.LA(1) <= VECTOR) ) 
            	{
            	    input.Consume();
            	    adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set114));
            	    state.errorRecovery = false;
            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "type"

    public class lvalue_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "lvalue"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:146:1: lvalue : IDENTIFIER ;
    public DSLParser.lvalue_return lvalue() // throws RecognitionException [1]
    {   
        DSLParser.lvalue_return retval = new DSLParser.lvalue_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken IDENTIFIER115 = null;

        CommonTree IDENTIFIER115_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:147:2: ( IDENTIFIER )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:147:4: IDENTIFIER
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	IDENTIFIER115=(IToken)Match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_lvalue1072); 
            		IDENTIFIER115_tree = (CommonTree)adaptor.Create(IDENTIFIER115);
            		adaptor.AddChild(root_0, IDENTIFIER115_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "lvalue"

    public class rvalue_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "rvalue"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:149:1: rvalue : IDENTIFIER ;
    public DSLParser.rvalue_return rvalue() // throws RecognitionException [1]
    {   
        DSLParser.rvalue_return retval = new DSLParser.rvalue_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken IDENTIFIER116 = null;

        CommonTree IDENTIFIER116_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:150:2: ( IDENTIFIER )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:150:4: IDENTIFIER
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	IDENTIFIER116=(IToken)Match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_rvalue1082); 
            		IDENTIFIER116_tree = (CommonTree)adaptor.Create(IDENTIFIER116);
            		adaptor.AddChild(root_0, IDENTIFIER116_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "rvalue"

    public class declaration_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "declaration"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:152:1: declaration : VARIABLE IDENTIFIER type ;
    public DSLParser.declaration_return declaration() // throws RecognitionException [1]
    {   
        DSLParser.declaration_return retval = new DSLParser.declaration_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken VARIABLE117 = null;
        IToken IDENTIFIER118 = null;
        DSLParser.type_return type119 = default(DSLParser.type_return);


        CommonTree VARIABLE117_tree=null;
        CommonTree IDENTIFIER118_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:153:2: ( VARIABLE IDENTIFIER type )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:153:4: VARIABLE IDENTIFIER type
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	VARIABLE117=(IToken)Match(input,VARIABLE,FOLLOW_VARIABLE_in_declaration1094); 
            		VARIABLE117_tree = (CommonTree)adaptor.Create(VARIABLE117);
            		root_0 = (CommonTree)adaptor.BecomeRoot(VARIABLE117_tree, root_0);

            	IDENTIFIER118=(IToken)Match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_declaration1097); 
            		IDENTIFIER118_tree = (CommonTree)adaptor.Create(IDENTIFIER118);
            		adaptor.AddChild(root_0, IDENTIFIER118_tree);

            	PushFollow(FOLLOW_type_in_declaration1099);
            	type119 = type();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, type119.Tree);

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "declaration"

    public class vectorassignment_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "vectorassignment"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:155:1: vectorassignment : ASSIGN_VECTOR lvalue '(' value ',' value ',' value ',' value ',' value ')' ;
    public DSLParser.vectorassignment_return vectorassignment() // throws RecognitionException [1]
    {   
        DSLParser.vectorassignment_return retval = new DSLParser.vectorassignment_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ASSIGN_VECTOR120 = null;
        IToken char_literal122 = null;
        IToken char_literal124 = null;
        IToken char_literal126 = null;
        IToken char_literal128 = null;
        IToken char_literal130 = null;
        IToken char_literal132 = null;
        DSLParser.lvalue_return lvalue121 = default(DSLParser.lvalue_return);

        DSLParser.value_return value123 = default(DSLParser.value_return);

        DSLParser.value_return value125 = default(DSLParser.value_return);

        DSLParser.value_return value127 = default(DSLParser.value_return);

        DSLParser.value_return value129 = default(DSLParser.value_return);

        DSLParser.value_return value131 = default(DSLParser.value_return);


        CommonTree ASSIGN_VECTOR120_tree=null;
        CommonTree char_literal122_tree=null;
        CommonTree char_literal124_tree=null;
        CommonTree char_literal126_tree=null;
        CommonTree char_literal128_tree=null;
        CommonTree char_literal130_tree=null;
        CommonTree char_literal132_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:156:2: ( ASSIGN_VECTOR lvalue '(' value ',' value ',' value ',' value ',' value ')' )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:156:4: ASSIGN_VECTOR lvalue '(' value ',' value ',' value ',' value ',' value ')'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	ASSIGN_VECTOR120=(IToken)Match(input,ASSIGN_VECTOR,FOLLOW_ASSIGN_VECTOR_in_vectorassignment1109); 
            		ASSIGN_VECTOR120_tree = (CommonTree)adaptor.Create(ASSIGN_VECTOR120);
            		root_0 = (CommonTree)adaptor.BecomeRoot(ASSIGN_VECTOR120_tree, root_0);

            	PushFollow(FOLLOW_lvalue_in_vectorassignment1112);
            	lvalue121 = lvalue();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, lvalue121.Tree);
            	char_literal122=(IToken)Match(input,LEFT_PARENTHESIS,FOLLOW_LEFT_PARENTHESIS_in_vectorassignment1114); 
            	PushFollow(FOLLOW_value_in_vectorassignment1117);
            	value123 = value();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, value123.Tree);
            	char_literal124=(IToken)Match(input,COMMA,FOLLOW_COMMA_in_vectorassignment1119); 
            	PushFollow(FOLLOW_value_in_vectorassignment1122);
            	value125 = value();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, value125.Tree);
            	char_literal126=(IToken)Match(input,COMMA,FOLLOW_COMMA_in_vectorassignment1124); 
            	PushFollow(FOLLOW_value_in_vectorassignment1127);
            	value127 = value();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, value127.Tree);
            	char_literal128=(IToken)Match(input,COMMA,FOLLOW_COMMA_in_vectorassignment1129); 
            	PushFollow(FOLLOW_value_in_vectorassignment1132);
            	value129 = value();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, value129.Tree);
            	char_literal130=(IToken)Match(input,COMMA,FOLLOW_COMMA_in_vectorassignment1134); 
            	PushFollow(FOLLOW_value_in_vectorassignment1137);
            	value131 = value();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, value131.Tree);
            	char_literal132=(IToken)Match(input,RIGHT_PARENTHESIS,FOLLOW_RIGHT_PARENTHESIS_in_vectorassignment1139); 

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "vectorassignment"

    public class assignment_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "assignment"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:158:1: assignment : lvalue '=' mathexpr ;
    public DSLParser.assignment_return assignment() // throws RecognitionException [1]
    {   
        DSLParser.assignment_return retval = new DSLParser.assignment_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken char_literal134 = null;
        DSLParser.lvalue_return lvalue133 = default(DSLParser.lvalue_return);

        DSLParser.mathexpr_return mathexpr135 = default(DSLParser.mathexpr_return);


        CommonTree char_literal134_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:159:2: ( lvalue '=' mathexpr )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:159:4: lvalue '=' mathexpr
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_lvalue_in_assignment1150);
            	lvalue133 = lvalue();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, lvalue133.Tree);
            	char_literal134=(IToken)Match(input,ASSIGNMENT,FOLLOW_ASSIGNMENT_in_assignment1152); 
            		char_literal134_tree = (CommonTree)adaptor.Create(char_literal134);
            		root_0 = (CommonTree)adaptor.BecomeRoot(char_literal134_tree, root_0);

            	PushFollow(FOLLOW_mathexpr_in_assignment1155);
            	mathexpr135 = mathexpr();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, mathexpr135.Tree);

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "assignment"

    public class plus_assignment_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "plus_assignment"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:161:1: plus_assignment : lvalue '+=' mathexpr ;
    public DSLParser.plus_assignment_return plus_assignment() // throws RecognitionException [1]
    {   
        DSLParser.plus_assignment_return retval = new DSLParser.plus_assignment_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken string_literal137 = null;
        DSLParser.lvalue_return lvalue136 = default(DSLParser.lvalue_return);

        DSLParser.mathexpr_return mathexpr138 = default(DSLParser.mathexpr_return);


        CommonTree string_literal137_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:162:2: ( lvalue '+=' mathexpr )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:162:5: lvalue '+=' mathexpr
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_lvalue_in_plus_assignment1166);
            	lvalue136 = lvalue();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, lvalue136.Tree);
            	string_literal137=(IToken)Match(input,PLUS_ASSIGNMENT,FOLLOW_PLUS_ASSIGNMENT_in_plus_assignment1168); 
            		string_literal137_tree = (CommonTree)adaptor.Create(string_literal137);
            		root_0 = (CommonTree)adaptor.BecomeRoot(string_literal137_tree, root_0);

            	PushFollow(FOLLOW_mathexpr_in_plus_assignment1171);
            	mathexpr138 = mathexpr();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, mathexpr138.Tree);

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "plus_assignment"

    public class minus_assignment_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "minus_assignment"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:164:1: minus_assignment : lvalue '-=' mathexpr ;
    public DSLParser.minus_assignment_return minus_assignment() // throws RecognitionException [1]
    {   
        DSLParser.minus_assignment_return retval = new DSLParser.minus_assignment_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken string_literal140 = null;
        DSLParser.lvalue_return lvalue139 = default(DSLParser.lvalue_return);

        DSLParser.mathexpr_return mathexpr141 = default(DSLParser.mathexpr_return);


        CommonTree string_literal140_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:165:2: ( lvalue '-=' mathexpr )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:165:4: lvalue '-=' mathexpr
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_lvalue_in_minus_assignment1181);
            	lvalue139 = lvalue();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, lvalue139.Tree);
            	string_literal140=(IToken)Match(input,MINUS_ASSIGNMENT,FOLLOW_MINUS_ASSIGNMENT_in_minus_assignment1183); 
            		string_literal140_tree = (CommonTree)adaptor.Create(string_literal140);
            		root_0 = (CommonTree)adaptor.BecomeRoot(string_literal140_tree, root_0);

            	PushFollow(FOLLOW_mathexpr_in_minus_assignment1186);
            	mathexpr141 = mathexpr();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, mathexpr141.Tree);

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "minus_assignment"

    public class plus_plus_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "plus_plus"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:167:1: plus_plus : lvalue '++' ;
    public DSLParser.plus_plus_return plus_plus() // throws RecognitionException [1]
    {   
        DSLParser.plus_plus_return retval = new DSLParser.plus_plus_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken string_literal143 = null;
        DSLParser.lvalue_return lvalue142 = default(DSLParser.lvalue_return);


        CommonTree string_literal143_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:168:2: ( lvalue '++' )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:168:4: lvalue '++'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_lvalue_in_plus_plus1196);
            	lvalue142 = lvalue();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, lvalue142.Tree);
            	string_literal143=(IToken)Match(input,PLUS_PLUS,FOLLOW_PLUS_PLUS_in_plus_plus1198); 
            		string_literal143_tree = (CommonTree)adaptor.Create(string_literal143);
            		root_0 = (CommonTree)adaptor.BecomeRoot(string_literal143_tree, root_0);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "plus_plus"

    public class minus_minus_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "minus_minus"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:170:1: minus_minus : lvalue '--' ;
    public DSLParser.minus_minus_return minus_minus() // throws RecognitionException [1]
    {   
        DSLParser.minus_minus_return retval = new DSLParser.minus_minus_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken string_literal145 = null;
        DSLParser.lvalue_return lvalue144 = default(DSLParser.lvalue_return);


        CommonTree string_literal145_tree=null;

        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:171:2: ( lvalue '--' )
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:171:4: lvalue '--'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_lvalue_in_minus_minus1209);
            	lvalue144 = lvalue();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, lvalue144.Tree);
            	string_literal145=(IToken)Match(input,MINUS_MINUS,FOLLOW_MINUS_MINUS_in_minus_minus1211); 
            		string_literal145_tree = (CommonTree)adaptor.Create(string_literal145);
            		root_0 = (CommonTree)adaptor.BecomeRoot(string_literal145_tree, root_0);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "minus_minus"

    public class statements_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "statements"
    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:173:1: statements : ( assignment | plus_assignment | minus_assignment | plus_plus | minus_minus );
    public DSLParser.statements_return statements() // throws RecognitionException [1]
    {   
        DSLParser.statements_return retval = new DSLParser.statements_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        DSLParser.assignment_return assignment146 = default(DSLParser.assignment_return);

        DSLParser.plus_assignment_return plus_assignment147 = default(DSLParser.plus_assignment_return);

        DSLParser.minus_assignment_return minus_assignment148 = default(DSLParser.minus_assignment_return);

        DSLParser.plus_plus_return plus_plus149 = default(DSLParser.plus_plus_return);

        DSLParser.minus_minus_return minus_minus150 = default(DSLParser.minus_minus_return);



        try 
    	{
            // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:174:2: ( assignment | plus_assignment | minus_assignment | plus_plus | minus_minus )
            int alt16 = 5;
            int LA16_0 = input.LA(1);

            if ( (LA16_0 == IDENTIFIER) )
            {
                switch ( input.LA(2) ) 
                {
                case ASSIGNMENT:
                	{
                    alt16 = 1;
                    }
                    break;
                case PLUS_PLUS:
                	{
                    alt16 = 4;
                    }
                    break;
                case MINUS_MINUS:
                	{
                    alt16 = 5;
                    }
                    break;
                case PLUS_ASSIGNMENT:
                	{
                    alt16 = 2;
                    }
                    break;
                case MINUS_ASSIGNMENT:
                	{
                    alt16 = 3;
                    }
                    break;
                	default:
                	    NoViableAltException nvae_d16s1 =
                	        new NoViableAltException("", 16, 1, input);

                	    throw nvae_d16s1;
                }

            }
            else 
            {
                NoViableAltException nvae_d16s0 =
                    new NoViableAltException("", 16, 0, input);

                throw nvae_d16s0;
            }
            switch (alt16) 
            {
                case 1 :
                    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:174:4: assignment
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_assignment_in_statements1221);
                    	assignment146 = assignment();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, assignment146.Tree);

                    }
                    break;
                case 2 :
                    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:175:5: plus_assignment
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_plus_assignment_in_statements1227);
                    	plus_assignment147 = plus_assignment();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, plus_assignment147.Tree);

                    }
                    break;
                case 3 :
                    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:176:5: minus_assignment
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_minus_assignment_in_statements1233);
                    	minus_assignment148 = minus_assignment();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, minus_assignment148.Tree);

                    }
                    break;
                case 4 :
                    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:177:5: plus_plus
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_plus_plus_in_statements1239);
                    	plus_plus149 = plus_plus();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, plus_plus149.Tree);

                    }
                    break;
                case 5 :
                    // C:\\Users\\Jonas\\Desktop\\My Dropbox\\I4PRJ4\\Antlr\\DSL.g:178:5: minus_minus
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_minus_minus_in_statements1245);
                    	minus_minus150 = minus_minus();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, minus_minus150.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "statements"

    // Delegated rules


	private void InitializeCyclicDFAs()
	{
	}

 

    public static readonly BitSet FOLLOW_value_in_expr459 = new BitSet(new ulong[]{0x000000003F000000UL});
    public static readonly BitSet FOLLOW_lvalue_in_expr463 = new BitSet(new ulong[]{0x000000003F000000UL});
    public static readonly BitSet FOLLOW_EQUALTO_in_expr469 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_NOTEQUALTO_in_expr474 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_LARGERTHANEQUALS_in_expr479 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_SMALLERTHANEQUALS_in_expr484 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_LARGERTHAN_in_expr489 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_SMALLERTHAN_in_expr494 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_value_in_expr502 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_rvalue_in_expr506 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_term_in_mathexpr516 = new BitSet(new ulong[]{0x0000000000000032UL});
    public static readonly BitSet FOLLOW_set_in_mathexpr520 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_term_in_mathexpr532 = new BitSet(new ulong[]{0x0000000000000032UL});
    public static readonly BitSet FOLLOW_factor_in_term545 = new BitSet(new ulong[]{0x00000000000000C2UL});
    public static readonly BitSet FOLLOW_lvalue_in_term549 = new BitSet(new ulong[]{0x00000000000000C2UL});
    public static readonly BitSet FOLLOW_set_in_term555 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_factor_in_term567 = new BitSet(new ulong[]{0x00000000000000C2UL});
    public static readonly BitSet FOLLOW_rvalue_in_term571 = new BitSet(new ulong[]{0x00000000000000C2UL});
    public static readonly BitSet FOLLOW_NUMBER_in_factor584 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_initialization_in_program595 = new BitSet(new ulong[]{0x0019BFFCC0C80000UL});
    public static readonly BitSet FOLLOW_functions_in_program597 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_STARTCONVEYER_in_functions611 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_STOPCONVEYER_in_functions616 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_MOVE_TO_WEIGHT_in_functions621 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_RELEASE_BRICK_in_functions627 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_WEIGH_BRICK_in_functions633 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_MOVE_TO_CONVEYER_in_functions638 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_MOVE_TO_SORTBOX_in_functions643 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_GRAP_BRICK_in_functions648 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_MEASURE_BRICK_in_functions654 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_rollgrapperR_in_functions659 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_rollgrapperL_in_functions664 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_pitchgrapperU_in_functions669 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_pitchgrapperD_in_functions674 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_declaration_in_functions679 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_statements_in_functions684 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_hvis_in_functions689 = new BitSet(new ulong[]{0x0019BFFCC0F80002UL});
    public static readonly BitSet FOLLOW_ellershvis_in_functions692 = new BitSet(new ulong[]{0x0019BFFCC0F80002UL});
    public static readonly BitSet FOLLOW_ellers_in_functions697 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_mens_in_functions703 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_loop_in_functions708 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_moveTo_in_functions713 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_vectorassignment_in_functions718 = new BitSet(new ulong[]{0x0019BFFCC0C80002UL});
    public static readonly BitSet FOLLOW_ROLL_GRAPPER_RIGHT_in_rollgrapperR732 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_LEFT_PARENTHESIS_in_rollgrapperR735 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_value_in_rollgrapperR738 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_RIGHT_PARENTHESIS_in_rollgrapperR740 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ROLL_GRAPPER_LEFT_in_rollgrapperL751 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_LEFT_PARENTHESIS_in_rollgrapperL754 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_value_in_rollgrapperL757 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_RIGHT_PARENTHESIS_in_rollgrapperL759 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_PITCH_GRAPPER_UP_in_pitchgrapperU770 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_LEFT_PARENTHESIS_in_pitchgrapperU773 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_value_in_pitchgrapperU776 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_RIGHT_PARENTHESIS_in_pitchgrapperU778 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_PITCH_GRAPPER_DOWN_in_pitchgrapperD790 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_LEFT_PARENTHESIS_in_pitchgrapperD793 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_value_in_pitchgrapperD796 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_RIGHT_PARENTHESIS_in_pitchgrapperD798 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_MOVE_TO_in_moveTo808 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_LEFT_PARENTHESIS_in_moveTo811 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_value_in_moveTo816 = new BitSet(new ulong[]{0x0000000000010000UL});
    public static readonly BitSet FOLLOW_COMMA_in_moveTo818 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_value_in_moveTo821 = new BitSet(new ulong[]{0x0000000000010000UL});
    public static readonly BitSet FOLLOW_COMMA_in_moveTo823 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_value_in_moveTo826 = new BitSet(new ulong[]{0x0000000000010000UL});
    public static readonly BitSet FOLLOW_COMMA_in_moveTo828 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_value_in_moveTo831 = new BitSet(new ulong[]{0x0000000000010000UL});
    public static readonly BitSet FOLLOW_COMMA_in_moveTo833 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_value_in_moveTo836 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_lvalue_in_moveTo841 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_RIGHT_PARENTHESIS_in_moveTo844 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_init_in_initialization856 = new BitSet(new ulong[]{0x0000000200000000UL});
    public static readonly BitSet FOLLOW_home_in_initialization858 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_HOME_in_home870 = new BitSet(new ulong[]{0x000000000000C002UL});
    public static readonly BitSet FOLLOW_LEFT_PARENTHESIS_in_home872 = new BitSet(new ulong[]{0x0000000000008002UL});
    public static readonly BitSet FOLLOW_RIGHT_PARENTHESIS_in_home876 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_INIT_in_init890 = new BitSet(new ulong[]{0x000000000000C002UL});
    public static readonly BitSet FOLLOW_LEFT_PARENTHESIS_in_init893 = new BitSet(new ulong[]{0x0000000000008002UL});
    public static readonly BitSet FOLLOW_RIGHT_PARENTHESIS_in_init897 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_HVIS_in_hvis910 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_LEFT_PARENTHESIS_in_hvis913 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_expr_in_hvis916 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_RIGHT_PARENTHESIS_in_hvis918 = new BitSet(new ulong[]{0x0000000000020000UL});
    public static readonly BitSet FOLLOW_LEFT_BRACKET_in_hvis921 = new BitSet(new ulong[]{0x0019BFFCC0CC0000UL});
    public static readonly BitSet FOLLOW_functions_in_hvis924 = new BitSet(new ulong[]{0x0000000000040000UL});
    public static readonly BitSet FOLLOW_RIGHT_BRACKET_in_hvis926 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ELLERSHVIS_in_ellershvis940 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_LEFT_PARENTHESIS_in_ellershvis943 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_expr_in_ellershvis946 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_RIGHT_PARENTHESIS_in_ellershvis948 = new BitSet(new ulong[]{0x0000000000020000UL});
    public static readonly BitSet FOLLOW_LEFT_BRACKET_in_ellershvis951 = new BitSet(new ulong[]{0x0019BFFCC0CC0000UL});
    public static readonly BitSet FOLLOW_functions_in_ellershvis954 = new BitSet(new ulong[]{0x0000000000040000UL});
    public static readonly BitSet FOLLOW_RIGHT_BRACKET_in_ellershvis956 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ELLERS_in_ellers969 = new BitSet(new ulong[]{0x0000000000020000UL});
    public static readonly BitSet FOLLOW_LEFT_BRACKET_in_ellers972 = new BitSet(new ulong[]{0x0019BFFCC0CC0000UL});
    public static readonly BitSet FOLLOW_functions_in_ellers975 = new BitSet(new ulong[]{0x0000000000040000UL});
    public static readonly BitSet FOLLOW_RIGHT_BRACKET_in_ellers977 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_MENS_in_mens989 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_LEFT_PARENTHESIS_in_mens992 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_expr_in_mens995 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_RIGHT_PARENTHESIS_in_mens997 = new BitSet(new ulong[]{0x0000000000020000UL});
    public static readonly BitSet FOLLOW_LEFT_BRACKET_in_mens1000 = new BitSet(new ulong[]{0x0019BFFCC0CC0000UL});
    public static readonly BitSet FOLLOW_functions_in_mens1003 = new BitSet(new ulong[]{0x0000000000040000UL});
    public static readonly BitSet FOLLOW_RIGHT_BRACKET_in_mens1005 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_LOOP_in_loop1018 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_LEFT_PARENTHESIS_in_loop1021 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_value_in_loop1024 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_RIGHT_PARENTHESIS_in_loop1026 = new BitSet(new ulong[]{0x0000000000020000UL});
    public static readonly BitSet FOLLOW_LEFT_BRACKET_in_loop1029 = new BitSet(new ulong[]{0x0019BFFCC0CC0000UL});
    public static readonly BitSet FOLLOW_functions_in_loop1032 = new BitSet(new ulong[]{0x0000000000040000UL});
    public static readonly BitSet FOLLOW_RIGHT_BRACKET_in_loop1034 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NUMBER_in_value1047 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_type0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_IDENTIFIER_in_lvalue1072 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_IDENTIFIER_in_rvalue1082 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_VARIABLE_in_declaration1094 = new BitSet(new ulong[]{0x0010000000000000UL});
    public static readonly BitSet FOLLOW_IDENTIFIER_in_declaration1097 = new BitSet(new ulong[]{0x0006000000000000UL});
    public static readonly BitSet FOLLOW_type_in_declaration1099 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ASSIGN_VECTOR_in_vectorassignment1109 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_lvalue_in_vectorassignment1112 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_LEFT_PARENTHESIS_in_vectorassignment1114 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_value_in_vectorassignment1117 = new BitSet(new ulong[]{0x0000000000010000UL});
    public static readonly BitSet FOLLOW_COMMA_in_vectorassignment1119 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_value_in_vectorassignment1122 = new BitSet(new ulong[]{0x0000000000010000UL});
    public static readonly BitSet FOLLOW_COMMA_in_vectorassignment1124 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_value_in_vectorassignment1127 = new BitSet(new ulong[]{0x0000000000010000UL});
    public static readonly BitSet FOLLOW_COMMA_in_vectorassignment1129 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_value_in_vectorassignment1132 = new BitSet(new ulong[]{0x0000000000010000UL});
    public static readonly BitSet FOLLOW_COMMA_in_vectorassignment1134 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_value_in_vectorassignment1137 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_RIGHT_PARENTHESIS_in_vectorassignment1139 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_lvalue_in_assignment1150 = new BitSet(new ulong[]{0x0000000000000100UL});
    public static readonly BitSet FOLLOW_ASSIGNMENT_in_assignment1152 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_mathexpr_in_assignment1155 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_lvalue_in_plus_assignment1166 = new BitSet(new ulong[]{0x0000000000000200UL});
    public static readonly BitSet FOLLOW_PLUS_ASSIGNMENT_in_plus_assignment1168 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_mathexpr_in_plus_assignment1171 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_lvalue_in_minus_assignment1181 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_MINUS_ASSIGNMENT_in_minus_assignment1183 = new BitSet(new ulong[]{0x0018000000000000UL});
    public static readonly BitSet FOLLOW_mathexpr_in_minus_assignment1186 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_lvalue_in_plus_plus1196 = new BitSet(new ulong[]{0x0000000000000800UL});
    public static readonly BitSet FOLLOW_PLUS_PLUS_in_plus_plus1198 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_lvalue_in_minus_minus1209 = new BitSet(new ulong[]{0x0000000000001000UL});
    public static readonly BitSet FOLLOW_MINUS_MINUS_in_minus_minus1211 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_assignment_in_statements1221 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_plus_assignment_in_statements1227 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_minus_assignment_in_statements1233 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_plus_plus_in_statements1239 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_minus_minus_in_statements1245 = new BitSet(new ulong[]{0x0000000000000002UL});

}
